﻿#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLuaBase.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class WorldMapBaseWorldMapConfigDataWrap 
    {
        public static void __Register(RealStatePtr L)
        {
			ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			System.Type type = typeof(WorldMapBase.WorldMapConfigData);
			Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
			Utils.EndObjectRegister(type, L, translator, null, null,
			    null, null, null);

		    Utils.BeginClassRegister(type, L, __CreateInstance, 76, 10, 9);
			Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadMapPrefabMap", _m_LoadMapPrefabMap_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadMapPointData", _m_LoadMapPointData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateMaPrefabMap", _m_UpdateMaPrefabMap_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapPrefabPath", _m_GetMapPrefabPath_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetWorldInitPoints", _m_SetWorldInitPoints_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadAllMapData", _m_LoadAllMapData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadMapData", _m_LoadMapData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateMapData", _m_UpdateMapData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadMapChunckData", _m_LoadMapChunckData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapData", _m_GetMapData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileData", _m_GetTileData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapChunckData", _m_GetMapChunckData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapPointHide", _m_GetMapPointHide_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetElementShow", _m_GetElementShow_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileDataIdx", _m_GetTileDataIdx_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileSize", _m_GetTileSize_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetChunckId", _m_GetChunckId_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileResId", _m_GetTileResId_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetOverSeaTileResId", _m_GetOverSeaTileResId_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileResId_0", _m_GetTileResId_0_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileGridByIndex", _m_GetTileGridByIndex_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Dispose", _m_Dispose_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapChunckPos", _m_GetMapChunckPos_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapIdxByPos", _m_GetMapIdxByPos_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapChunckDataIdx", _m_GetMapChunckDataIdx_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapChunckDataIdxByRotation", _m_GetMapChunckDataIdxByRotation_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPosByAngle", _m_GetPosByAngle_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPosByAngle2", _m_GetPosByAngle2_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileOffset", _m_GetTileOffset_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTileElementByAngle", _m_GetTileElementByAngle_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetMapChunckLevel", _m_SetMapChunckLevel_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapChunckLevel", _m_GetMapChunckLevel_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetMapDebug", _m_SetMapDebug_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapDebug", _m_GetMapDebug_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetMapDebugChunckEntityNum", _m_SetMapDebugChunckEntityNum_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapDebugChunckEntityNum", _m_GetMapDebugChunckEntityNum_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMapChunckEntityTypeByResId", _m_GetMapChunckEntityTypeByResId_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetMapDebugChunckShowId", _m_SetMapDebugChunckShowId_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetChunckInfoById", _m_GetChunckInfoById_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetChunckIdByInfo", _m_GetChunckIdByInfo_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadMapFogData", _m_LoadMapFogData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateMapFogData", _m_UpdateMapFogData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFogIdByIndex", _m_GetFogIdByIndex_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFogTilesById", _m_GetFogTilesById_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFogData", _m_GetFogData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "InitChunckData", _m_InitChunckData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRoad", _m_GetRoad_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCross", _m_GetCross_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "InitChunckAdornData", _m_InitChunckAdornData_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_n", _m_AddAdornLevel_n_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_2", _m_AddAdornLevel_2_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_1", _m_AddAdornLevel_1_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_null", _m_AddAdornLevel_null_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_road", _m_AddAdornLevel_road_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_null2", _m_AddAdornLevel_null2_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_n2", _m_AddAdornLevel_n2_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_22", _m_AddAdornLevel_22_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_12", _m_AddAdornLevel_12_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddAdornLevel_road2", _m_AddAdornLevel_road2_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AddChunckCfgIdx", _m_AddChunckCfgIdx_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAdornDatas", _m_GetAdornDatas_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetChunckAdornDatas", _m_GetChunckAdornDatas_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAlliancePointIdxIsDelete", _m_GetAlliancePointIdxIsDelete_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPosByPosIdx", _m_GetPosByPosIdx_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPosByCfgIdx", _m_GetPosByCfgIdx_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetOverSeaTileIdx", _m_GetOverSeaTileIdx_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckTileInWorld", _m_CheckTileInWorld_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetOverSeaChunckInfo", _m_GetOverSeaChunckInfo_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetOverSeaWorldPosByIdx", _m_GetOverSeaWorldPosByIdx_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckPosInWorld", _m_CheckPosInWorld_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckPointInOverSea", _m_CheckPointInOverSea_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "rayCasting", _m_rayCasting_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "SetSceneType", _m_SetSceneType_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSceneType", _m_GetSceneType_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckTileShow", _m_CheckTileShow_xlua_st_);
            
			
            
			Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ResourceDatas", _g_get_ResourceDatas);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "m_mapWorldDataMaxIdx", _g_get_m_mapWorldDataMaxIdx);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MapPrefabMapRunTime", _g_get_MapPrefabMapRunTime);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "bMapChunckDateInit", _g_get_bMapChunckDateInit);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "_allianceChunckPointLineNum", _g_get__allianceChunckPointLineNum);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "_alliancePointSize", _g_get__alliancePointSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "_allianceTileLineNum", _g_get__allianceTileLineNum);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "_allianceMapPointLineNum", _g_get__allianceMapPointLineNum);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "_allainceTildHalfSize", _g_get__allainceTildHalfSize);
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MapPointPosRunTime", _g_get_MapPointPosRunTime);
            
			Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "m_mapWorldDataMaxIdx", _s_set_m_mapWorldDataMaxIdx);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MapPrefabMapRunTime", _s_set_MapPrefabMapRunTime);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "bMapChunckDateInit", _s_set_bMapChunckDateInit);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "_allianceChunckPointLineNum", _s_set__allianceChunckPointLineNum);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "_alliancePointSize", _s_set__alliancePointSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "_allianceTileLineNum", _s_set__allianceTileLineNum);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "_allianceMapPointLineNum", _s_set__allianceMapPointLineNum);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "_allainceTildHalfSize", _s_set__allainceTildHalfSize);
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MapPointPosRunTime", _s_set_MapPointPosRunTime);
            
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "New", __CreateInstanceNew);
			Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 1)
				{
					
					var gen_ret = new WorldMapBase.WorldMapConfigData();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to WorldMapBase.WorldMapConfigData constructor!");
            
        }

        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstanceNew(RealStatePtr L)
        {
            
			try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
				if(LuaAPI.lua_gettop(L) == 0)
				{
					
					var gen_ret = new WorldMapBase.WorldMapConfigData();
					translator.Push(L, gen_ret);
                    
					return 1;
				}
				
			}
			catch(System.Exception gen_e) {
				return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
			}
            return LuaAPI.luaL_error(L, "invalid arguments to WorldMapBase.WorldMapConfigData constructor!");
            
        }

        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadMapPrefabMap_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaFunction _callBack = (XLua.LuaFunction)translator.GetObject(L, 1, typeof(XLua.LuaFunction));
                    
                    WorldMapBase.WorldMapConfigData.LoadMapPrefabMap( _callBack );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadMapPointData_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    WorldMapBase.WorldMapConfigData.LoadMapPointData(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateMaPrefabMap_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    object _asset = translator.GetObject(L, 1, typeof(object));
                    
                    WorldMapBase.WorldMapConfigData.UpdateMaPrefabMap( _asset );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapPrefabPath_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _resId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapPrefabPath( _resId );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetWorldInitPoints_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& translator.Assignable<UnityEngine.Vector2>(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    UnityEngine.Vector2 _pos;translator.Get(L, 1, out _pos);
                    bool _bClear = LuaAPI.lua_toboolean(L, 2);
                    
                    WorldMapBase.WorldMapConfigData.SetWorldInitPoints( _pos, _bClear );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& translator.Assignable<UnityEngine.Vector2>(L, 1)) 
                {
                    UnityEngine.Vector2 _pos;translator.Get(L, 1, out _pos);
                    
                    WorldMapBase.WorldMapConfigData.SetWorldInitPoints( _pos );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to WorldMapBase.WorldMapConfigData.SetWorldInitPoints!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadAllMapData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaFunction _luaFunc = (XLua.LuaFunction)translator.GetObject(L, 1, typeof(XLua.LuaFunction));
                    int _sceneType = LuaAPI.xlua_tointeger(L, 2);
                    
                    WorldMapBase.WorldMapConfigData.LoadAllMapData( _luaFunc, _sceneType );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadMapData_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _sceneType = LuaAPI.xlua_tointeger(L, 1);
                    
                    WorldMapBase.WorldMapConfigData.LoadMapData( _sceneType );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateMapData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    object _asset = translator.GetObject(L, 1, typeof(object));
                    int _mapType = LuaAPI.xlua_tointeger(L, 2);
                    
                    WorldMapBase.WorldMapConfigData.UpdateMapData( _asset, _mapType );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadMapChunckData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    Yoozoo.Managers.ResourceManagerV2.Runtime.ResLoader _resload = (Yoozoo.Managers.ResourceManagerV2.Runtime.ResLoader)translator.GetObject(L, 2, typeof(Yoozoo.Managers.ResourceManagerV2.Runtime.ResLoader));
                    
                    WorldMapBase.WorldMapConfigData.LoadMapChunckData( _chunckId, _resload );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapData(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _layer = LuaAPI.xlua_tointeger(L, 1);
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 3);
                    int _tileSize;
                    int _layerIdx;
                    int _chunckResId;
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileData( _layer, _lodIndex, _tileIndex, out _tileSize, out _layerIdx, out _chunckResId );
                        translator.Push(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _tileSize);
                        
                    LuaAPI.xlua_pushinteger(L, _layerIdx);
                        
                    LuaAPI.xlua_pushinteger(L, _chunckResId);
                        
                    
                    
                    
                    return 4;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapChunckData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapChunckData( _id );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapPointHide_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _pointId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapPointHide( _pointId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetElementShow_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _chuncIdx = LuaAPI.xlua_tointeger(L, 1);
                    int _itemIdx = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetElementShow( _chuncIdx, _itemIdx );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileDataIdx_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _layer = LuaAPI.xlua_tointeger(L, 1);
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileDataIdx( _layer, _lodIndex, _tileIndex );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileSize_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _layer = LuaAPI.xlua_tointeger(L, 1);
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileSize( _layer, _lodIndex );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetChunckId_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 1);
                    int _rotation;
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetChunckId( _tileIdx, out _rotation );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _rotation);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileResId_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 1);
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _tileSize;
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileResId( _lodIndex, _tileIndex, out _tileSize );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _tileSize);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetOverSeaTileResId_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 1);
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _tileSize;
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetOverSeaTileResId( _lodIndex, _tileIndex, out _tileSize );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _tileSize);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileResId_0_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _resId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileResId_0( _resId );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileGridByIndex_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _layer = LuaAPI.xlua_tointeger(L, 1);
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileGridByIndex( _layer, _lodIndex, _tileIndex );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Dispose_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                    WorldMapBase.WorldMapConfigData.Dispose(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapChunckPos_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _layer = LuaAPI.xlua_tointeger(L, 1);
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _idx = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapChunckPos( _layer, _lodIndex, _idx );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapIdxByPos_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.Vector2 _pos;translator.Get(L, 1, out _pos);
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 2);
                    int _lineNum;
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapIdxByPos( _pos, _lodIndex, out _lineNum );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _lineNum);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapChunckDataIdx_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _lodIndex = LuaAPI.xlua_tointeger(L, 1);
                    int _tileSize = LuaAPI.xlua_tointeger(L, 2);
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 3);
                    int _rotation = LuaAPI.xlua_tointeger(L, 4);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapChunckDataIdx( _lodIndex, _tileSize, _tileIdx, _rotation );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapChunckDataIdxByRotation_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _idx_x = LuaAPI.xlua_tointeger(L, 1);
                    int _idx_y = LuaAPI.xlua_tointeger(L, 2);
                    int _granuleNum = LuaAPI.xlua_tointeger(L, 3);
                    int _rotation = LuaAPI.xlua_tointeger(L, 4);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapChunckDataIdxByRotation( _idx_x, _idx_y, _granuleNum, _rotation );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPosByAngle_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 1);
                    float _y = (float)LuaAPI.lua_tonumber(L, 2);
                    float _z = (float)LuaAPI.lua_tonumber(L, 3);
                    int _r = LuaAPI.xlua_tointeger(L, 4);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetPosByAngle( _x, _y, _z, _r );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPosByAngle2_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 1);
                    float _y = (float)LuaAPI.lua_tonumber(L, 2);
                    float _z = (float)LuaAPI.lua_tonumber(L, 3);
                    int _r = LuaAPI.xlua_tointeger(L, 4);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetPosByAngle2( _x, _y, _z, _r );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileOffset_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileOffset( _tileIdx );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTileElementByAngle_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    WorldMapNew.TileElement _element = (WorldMapNew.TileElement)translator.GetObject(L, 1, typeof(WorldMapNew.TileElement));
                    WorldMapBase.WorldMapConfigData.chunckInfoDta _data = (WorldMapBase.WorldMapConfigData.chunckInfoDta)translator.GetObject(L, 2, typeof(WorldMapBase.WorldMapConfigData.chunckInfoDta));
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetTileElementByAngle( _element, _data );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMapChunckLevel_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _level = LuaAPI.xlua_tointeger(L, 1);
                    
                    WorldMapBase.WorldMapConfigData.SetMapChunckLevel( _level );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapChunckLevel_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapChunckLevel(  );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMapDebug_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    bool _value = LuaAPI.lua_toboolean(L, 1);
                    
                    WorldMapBase.WorldMapConfigData.SetMapDebug( _value );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapDebug_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapDebug(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMapDebugChunckEntityNum_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _type = LuaAPI.xlua_tointeger(L, 1);
                    int _num = LuaAPI.xlua_tointeger(L, 2);
                    
                    WorldMapBase.WorldMapConfigData.SetMapDebugChunckEntityNum( _type, _num );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapDebugChunckEntityNum_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _type = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapDebugChunckEntityNum( _type );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetMapChunckEntityTypeByResId_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _resId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetMapChunckEntityTypeByResId( _resId );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetMapDebugChunckShowId_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    
                    WorldMapBase.WorldMapConfigData.SetMapDebugChunckShowId( _chunckId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetChunckInfoById_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetChunckInfoById( _chunckId );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetChunckIdByInfo_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    WorldMapBase.WorldMapConfigData.chunckInfoDta _data = (WorldMapBase.WorldMapConfigData.chunckInfoDta)translator.GetObject(L, 1, typeof(WorldMapBase.WorldMapConfigData.chunckInfoDta));
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetChunckIdByInfo( _data );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadMapFogData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    XLua.LuaFunction _callBack = (XLua.LuaFunction)translator.GetObject(L, 1, typeof(XLua.LuaFunction));
                    
                    WorldMapBase.WorldMapConfigData.LoadMapFogData( _callBack );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateMapFogData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    object _asset = translator.GetObject(L, 1, typeof(object));
                    
                    WorldMapBase.WorldMapConfigData.UpdateMapFogData( _asset );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetFogIdByIndex_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _idx = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetFogIdByIndex( _idx );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetFogTilesById_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetFogTilesById( _id );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetFogData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetFogData(  );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InitChunckData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    System.Collections.Generic.List<WorldMapNew.TileAlliancePointRoad> _alliancePointRoads = (System.Collections.Generic.List<WorldMapNew.TileAlliancePointRoad>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<WorldMapNew.TileAlliancePointRoad>));
                    System.Collections.Generic.List<WorldMapNew.TileAlliancePointCross> _alliancePointCross = (System.Collections.Generic.List<WorldMapNew.TileAlliancePointCross>)translator.GetObject(L, 3, typeof(System.Collections.Generic.List<WorldMapNew.TileAlliancePointCross>));
                    
                    WorldMapBase.WorldMapConfigData.InitChunckData( _chunckId, _alliancePointRoads, _alliancePointCross );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetRoad_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _localIdx = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetRoad( _chunckId, _localIdx );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetCross_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _localIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _angleIdx = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetCross( _chunckId, _localIdx, _angleIdx );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_InitChunckAdornData_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    WorldMapNew.MapChunckData _data = (WorldMapNew.MapChunckData)translator.GetObject(L, 2, typeof(WorldMapNew.MapChunckData));
                    
                    WorldMapBase.WorldMapConfigData.InitChunckAdornData( _chunckId, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_n_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _pointCfgIdx = LuaAPI.xlua_tointeger(L, 2);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 3, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_n( _chunckId, _pointCfgIdx, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_2_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _pointCfgIdx = LuaAPI.xlua_tointeger(L, 2);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 3, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_2( _chunckId, _pointCfgIdx, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_1_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _pointCfgIdx = LuaAPI.xlua_tointeger(L, 2);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 3, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_1( _chunckId, _pointCfgIdx, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_null_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _pointCfgIdx = LuaAPI.xlua_tointeger(L, 2);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 3, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_null( _chunckId, _pointCfgIdx, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_road_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _pointCfgIdx = LuaAPI.xlua_tointeger(L, 2);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 3, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_road( _chunckId, _pointCfgIdx, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_null2_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 2, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_null2( _chunckId, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_n2_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 2, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_n2( _chunckId, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_22_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 2, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_22( _chunckId, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_12_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 2, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_12( _chunckId, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddAdornLevel_road2_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    WorldMapNew.TilePointAdornData _data = (WorldMapNew.TilePointAdornData)translator.GetObject(L, 2, typeof(WorldMapNew.TilePointAdornData));
                    
                    WorldMapBase.WorldMapConfigData.AddAdornLevel_road2( _chunckId, _data );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddChunckCfgIdx_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    WorldMapNew.MapChunckLayer _layer = (WorldMapNew.MapChunckLayer)translator.GetObject(L, 2, typeof(WorldMapNew.MapChunckLayer));
                    
                    WorldMapBase.WorldMapConfigData.AddChunckCfgIdx( _chunckId, _layer );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetAdornDatas_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _pointCfgIdx = LuaAPI.xlua_tointeger(L, 2);
                    int _type = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetAdornDatas( _chunckId, _pointCfgIdx, _type );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetChunckAdornDatas_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _type = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetChunckAdornDatas( _chunckId, _type );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetAlliancePointIdxIsDelete_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _mapIdx = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetAlliancePointIdxIsDelete( _mapIdx );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPosByPosIdx_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
			    int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _posIdx = LuaAPI.xlua_tointeger(L, 1);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetPosByPosIdx( _posIdx );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    int _tileIdx = LuaAPI.xlua_tointeger(L, 1);
                    int _posIdx = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetPosByPosIdx( _tileIdx, _posIdx );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to WorldMapBase.WorldMapConfigData.GetPosByPosIdx!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPosByCfgIdx_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _chunckId = LuaAPI.xlua_tointeger(L, 1);
                    int _cfgIdx = LuaAPI.xlua_tointeger(L, 2);
                    bool _find;
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetPosByCfgIdx( _chunckId, _cfgIdx, out _find );
                        translator.PushUnityEngineVector3(L, gen_ret);
                    LuaAPI.lua_pushboolean(L, _find);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetOverSeaTileIdx_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _tile_x = LuaAPI.xlua_tointeger(L, 1);
                    int _tile_y = LuaAPI.xlua_tointeger(L, 2);
                    int _tileSize = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetOverSeaTileIdx( _tile_x, _tile_y, _tileSize );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckTileInWorld_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _tile_x = LuaAPI.xlua_tointeger(L, 1);
                    int _tile_y = LuaAPI.xlua_tointeger(L, 2);
                    int _tileSize = LuaAPI.xlua_tointeger(L, 3);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.CheckTileInWorld( _tile_x, _tile_y, _tileSize );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetOverSeaChunckInfo_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _lod = LuaAPI.xlua_tointeger(L, 1);
                    int _tileIndex = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetOverSeaChunckInfo( _lod, _tileIndex );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetOverSeaWorldPosByIdx_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _idx = LuaAPI.xlua_tointeger(L, 1);
                    int _tileSize = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetOverSeaWorldPosByIdx( _idx, _tileSize );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckPosInWorld_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _x = LuaAPI.xlua_tointeger(L, 1);
                    int _y = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.CheckPosInWorld( _x, _y );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckPointInOverSea_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    float _x = (float)LuaAPI.lua_tonumber(L, 1);
                    float _y = (float)LuaAPI.lua_tonumber(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.CheckPointInOverSea( _x, _y );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_rayCasting_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    UnityEngine.Vector2 _p;translator.Get(L, 1, out _p);
                    System.Collections.Generic.List<UnityEngine.Vector2> _poly = (System.Collections.Generic.List<UnityEngine.Vector2>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Vector2>));
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.rayCasting( _p, _poly );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetSceneType_xlua_st_(RealStatePtr L)
        {
		    try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _sceneType = LuaAPI.xlua_tointeger(L, 1);
                    XLua.LuaFunction _luaFunc = (XLua.LuaFunction)translator.GetObject(L, 2, typeof(XLua.LuaFunction));
                    
                    WorldMapBase.WorldMapConfigData.SetSceneType( _sceneType, _luaFunc );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSceneType_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.GetSceneType(  );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckTileShow_xlua_st_(RealStatePtr L)
        {
		    try {
            
            
            
                
                {
                    int _tileX = LuaAPI.xlua_tointeger(L, 1);
                    int _tileY = LuaAPI.xlua_tointeger(L, 2);
                    
                        var gen_ret = WorldMapBase.WorldMapConfigData.CheckTileShow( _tileX, _tileY );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_ResourceDatas(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, WorldMapBase.WorldMapConfigData.ResourceDatas);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_m_mapWorldDataMaxIdx(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldMapBase.WorldMapConfigData.m_mapWorldDataMaxIdx);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MapPrefabMapRunTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, WorldMapBase.WorldMapConfigData.MapPrefabMapRunTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_bMapChunckDateInit(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.lua_pushboolean(L, WorldMapBase.WorldMapConfigData.bMapChunckDateInit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get__allianceChunckPointLineNum(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldMapBase.WorldMapConfigData._allianceChunckPointLineNum);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get__alliancePointSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldMapBase.WorldMapConfigData._alliancePointSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get__allianceTileLineNum(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldMapBase.WorldMapConfigData._allianceTileLineNum);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get__allianceMapPointLineNum(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldMapBase.WorldMapConfigData._allianceMapPointLineNum);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get__allainceTildHalfSize(RealStatePtr L)
        {
		    try {
            
			    LuaAPI.xlua_pushinteger(L, WorldMapBase.WorldMapConfigData._allainceTildHalfSize);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MapPointPosRunTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    translator.Push(L, WorldMapBase.WorldMapConfigData.MapPointPosRunTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_m_mapWorldDataMaxIdx(RealStatePtr L)
        {
		    try {
                
			    WorldMapBase.WorldMapConfigData.m_mapWorldDataMaxIdx = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MapPrefabMapRunTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    WorldMapBase.WorldMapConfigData.MapPrefabMapRunTime = (System.Collections.Generic.Dictionary<int, string>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<int, string>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_bMapChunckDateInit(RealStatePtr L)
        {
		    try {
                
			    WorldMapBase.WorldMapConfigData.bMapChunckDateInit = LuaAPI.lua_toboolean(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set__allianceChunckPointLineNum(RealStatePtr L)
        {
		    try {
                
			    WorldMapBase.WorldMapConfigData._allianceChunckPointLineNum = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set__alliancePointSize(RealStatePtr L)
        {
		    try {
                
			    WorldMapBase.WorldMapConfigData._alliancePointSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set__allianceTileLineNum(RealStatePtr L)
        {
		    try {
                
			    WorldMapBase.WorldMapConfigData._allianceTileLineNum = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set__allianceMapPointLineNum(RealStatePtr L)
        {
		    try {
                
			    WorldMapBase.WorldMapConfigData._allianceMapPointLineNum = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set__allainceTildHalfSize(RealStatePtr L)
        {
		    try {
                
			    WorldMapBase.WorldMapConfigData._allainceTildHalfSize = LuaAPI.xlua_tointeger(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_MapPointPosRunTime(RealStatePtr L)
        {
		    try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			    WorldMapBase.WorldMapConfigData.MapPointPosRunTime = (System.Collections.Generic.Dictionary<int, System.Collections.Generic.Dictionary<int, UnityEngine.Vector3>>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<int, System.Collections.Generic.Dictionary<int, UnityEngine.Vector3>>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, $"c# exception: {gen_e}\n{Yoozoo.Framework.Managers.LuaManager.GetTraceBack()}");
            }
            return 0;
        }
        
		
		
		
		
    }
}
